#include <iostream>
#include <mutex>
#include <thread>
#include <vector>
// 懒汉模式 - 静态成员变量
// 优点：程序启动时不创建对象，节省资源
// 缺点：需要加锁，线程安全
std::mutex mtx;
class Singleton
{
private:
    // 私有构造函数，防止外部创建对象
    Singleton()
    {
        std::cout << "Singleton instance created." << std::endl;
    }

    // 禁用拷贝构造函数
    Singleton(const Singleton &) = delete;
    // 禁用拷贝赋值运算符
    Singleton &operator=(const Singleton &) = delete;

    // 静态成员变量，存储单例对象的指针
    static std::unique_ptr<Singleton> instance;

public:
    static Singleton &getInstance()
    {
        {
            std::lock_guard<std::mutex> lock(mtx);
            if (instance == nullptr)
            {
                instance = std::unique_ptr<Singleton>(new Singleton());
            }
        }

        return *instance;
    }
};

// 初始化静态成员变量
std::unique_ptr<Singleton> Singleton::instance = nullptr;

// 线程函数，用于调用 getInstance 方法
void threadFunction()
{
    Singleton &singleton = Singleton::getInstance();
    std::cout << "Thread ID: " << std::this_thread::get_id() << ", Singleton address: " << &singleton << std::endl;
}
int main()
{

    const int numThreads = 10;
    std::vector<std::thread> threads;

    // 创建多个线程
    for (int i = 0; i < numThreads; ++i)
    {
        threads.emplace_back(threadFunction);
    }

    // 等待所有线程完成
    for (auto &thread : threads)
    {
        thread.join();
    }
    return 0;
}